package br.edu.ufcg.splab.util;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import br.edu.ufcg.splab.core.InterfaceEdge;
import br.edu.ufcg.splab.generator.TestCase;
import br.edu.ufcg.splab.generator.TestSuite;

public class MapFaultAndTestSuite {
	private final String TAB = "	";
	private final String EOL = System.getProperty("line.separator");
	
	//identification of each test case
	private Map<Integer, TestCase> mapTS;	
	//identification of each fault
	private Map<Integer, List<String>> mapFaults;
		
	//test cases that detect each fault
	private Map<Integer, List<Integer>> mapFaultTCs;
	private Map<Integer, List<Integer>> mapTCFaults;
	
	
	public MapFaultAndTestSuite(TestSuite testSuite, List<List<String>> faultsTransitions) {
		mapTS = new HashMap<Integer, TestCase>();
		mapFaults = new HashMap<Integer, List<String>>();
		mapFaultTCs = new HashMap<Integer, List<Integer>>();
		mapTCFaults = new HashMap<Integer, List<Integer>>();
		
		createMapTS(testSuite);
		createMapFaults(faultsTransitions);
		
		if(!faultsTransitions.isEmpty()){
			createFaultTestCases();
		}
	}
	
	public MapFaultAndTestSuite(TestSuite testSuite, Map<Integer, List<String>> map) {
		mapTS = new HashMap<Integer, TestCase>();
		this.mapFaults = map;
		mapFaultTCs = new HashMap<Integer, List<Integer>>();
		mapTCFaults = new HashMap<Integer, List<Integer>>();
		
		createMapTS(testSuite);
		createMapFaults(map);
		
		createFaultTestCases(map);
	}
	
	public MapFaultAndTestSuite(TestSuite testSuite, Map<Integer, List<String>> mapFaults, List<TestCase> failures) {
		mapTS = new HashMap<Integer, TestCase>();
		this.mapFaults = mapFaults;
		
		mapFaultTCs = new HashMap<Integer, List<Integer>>();
		mapTCFaults = new HashMap<Integer, List<Integer>>();
		
		createMapTS(testSuite);
		createMapFaults(getFaults());
		
		createFaultTestCases(mapFaults, failures);
	}
	
	public MapFaultAndTestSuite(TestSuite testSuite, Map<Integer, List<String>> map, Set<Integer> faults) {
		mapTS = new HashMap<Integer, TestCase>();
		//this.mapFaults = mapFaults;
		
		mapFaultTCs = new HashMap<Integer, List<Integer>>();
		mapTCFaults = new HashMap<Integer, List<Integer>>();
		
		createMapTS(testSuite);
		createMapFaults(map, faults);
		
		createFaultTestCases(faults);
	}
	 
	public MapFaultAndTestSuite(Map<Integer, TestCase> mapTS1, Map<Integer, List<String>> map, Set<Integer> faults) {
		mapTS = new HashMap<Integer, TestCase>();
		//this.mapFaults = mapFaults;
		mapFaultTCs = new HashMap<Integer, List<Integer>>();
		mapTCFaults = new HashMap<Integer, List<Integer>>();
		
		this.mapTS = mapTS1;
		
		//createMapTS(testSuite);
		createMapFaults(map, faults);
		
		createFaultTestCases(faults);
	}
	 
	
	public MapFaultAndTestSuite(TestSuite testSuite) {
		mapTS = new HashMap<Integer, TestCase>();
		mapFaults = new HashMap<Integer, List<String>>();
		mapFaultTCs = new HashMap<Integer, List<Integer>>();
		mapTCFaults = new HashMap<Integer, List<Integer>>();
		
		createMapTS(testSuite);
		
	}
	
	public Map<Integer, List<String>> getMapFaults() {
		return mapFaults;
	}
	
	public void setMapFault(Map<Integer, List<TestCase>> mapFault){
		Set<Entry<Integer, List<TestCase>>> set = mapFault.entrySet();
		Iterator<Entry<Integer, List<TestCase>>> it = set.iterator();
		while(it.hasNext()){
			Entry<Integer, List<TestCase>> entry = it.next();
			
			List<Integer> list = new ArrayList<Integer>();
			for(TestCase tc:entry.getValue()){
				list.add(getValueTestCase(tc));					
				if(this.mapTCFaults.containsKey(getValueTestCase(tc))){
					mapTCFaults.get(getValueTestCase(tc)).add(entry.getKey());
				}else{
					List<Integer> list2 = new ArrayList<Integer>();
					list2.add(entry.getKey());
					mapTCFaults.put(getValueTestCase(tc), list2);
				}
				
			}
			mapFaultTCs.put(entry.getKey(), list);
			
		}
	}
		
	public Map<Integer, TestCase> getMapTS() {
		return mapTS;
	}
	
	public Map<Integer, List<Integer>> getMapFaultTCs() {
		return mapFaultTCs;
	}

	public int numberOfFaults(){
		return mapFaultTCs.size();
	}
	
	public int numberOfTestCases(){
		return mapTS.size();
	}
	
	public List<Integer> getTestCasesThatDetectedFault(List<String> fault){
		int idFault = getValueFault(fault);
		return mapFaultTCs.get(idFault);
	}
	
	public int getNumberOfFailures(int faultId){	
		List<Integer> l = mapFaultTCs.get(faultId);
		if(l == null){
			return 0;
		}
		return mapFaultTCs.get(faultId).size();
	}
	
	public List<Integer> getFailures(){
		List<Integer> failures = new ArrayList<Integer>();
		Set<Entry<Integer, List<Integer>>> setEntry = mapTCFaults.entrySet();
		for (Iterator<Entry<Integer, List<Integer>>> iterator = setEntry.iterator(); iterator.hasNext();) {
			Entry<Integer, List<Integer>> entry = (Entry<Integer, List<Integer>>) iterator.next();
			if(!failures.contains(entry.getKey())){
				failures.add(entry.getKey());
			}
		}
		return failures;
	}
	
	public boolean isFailure(TestCase testCase){
		for(TestCase tc: getTestCasesThatFailure()){
			if(getValueTestCase(tc) == getValueTestCase(testCase)){
				return true;
			}
		}
		return false;
	}
	
	public List<Integer> getFaultsThatDetectedTestCase(TestCase testCase){
		int idTC = getValueTestCase(testCase);
		List<Integer> l = new ArrayList<Integer>();
		List<Integer> l1 = mapTCFaults.get(idTC);
		if(l1 != null){
			return l1;
		}
		return l;
	}

	public List<Integer> getFaultsThatDetectedTestCase(int idTestCase){
		return mapTCFaults.get(idTestCase);
	}
	
	public int getValueFault(List<String> fault){
		Set<Entry<Integer, List<String>>> setEntry = mapFaults.entrySet();
		for (Iterator<Entry<Integer, List<String>>> iterator = setEntry.iterator(); iterator.hasNext();) {
			Entry<Integer, List<String>> entry = (Entry<Integer, List<String>>) iterator.next();
			if(fault.equals(entry.getValue())){
				return entry.getKey();
			}
		}
		
		return -1;
	}
	
	public List<TestCase> getTestCases(){
		List<TestCase> testCases = new ArrayList<TestCase>();
		Set<Entry<Integer, TestCase>> set = mapTS.entrySet();
		for(Entry<Integer, TestCase> entry:set){
			testCases.add(entry.getValue());
		}
		return testCases;
	}
	
	public List<TestCase> getTestCasesThatFailure(){
		List<TestCase> testCases = new ArrayList<TestCase>();
		Set<Entry<Integer, List<Integer>>> set = mapTCFaults.entrySet();
		for(Entry<Integer, List<Integer>> entry:set){
			testCases.add(getTestCase(entry.getKey()));
		}
		return testCases;
	}
	
	public boolean containsFailure(TestCase testCase){
		List<TestCase> failures = getTestCasesThatFailure();
		for(TestCase t:failures){
			if(t.equals(testCase)){
				return true;
			}
		}
		return false;
	}
	
	public int getValueTestCase(TestCase testCase){
		if(mapTS.containsValue(testCase)){
			Set<Entry<Integer, TestCase>> set = mapTS.entrySet();
			for(Entry<Integer, TestCase> entry:set){
				if(entry.getValue().equals(testCase)){
					return entry.getKey();
				}
			}
		};
		return -1;
	}
	
	public boolean isOneFailureForOneFault(){
		Set<Entry<Integer, List<Integer>>> set = mapTCFaults.entrySet();
		for(Entry<Integer, List<Integer>> entry:set){
			if(entry.getValue().size() > 1) {
				return false;
			}	
		}
		return true;
	}

	public void toStringMapTS(){
		Set<Entry<Integer, TestCase>> set = mapTS.entrySet();
		for(Entry<Integer, TestCase> entry:set){
			System.out.println(entry.getKey() + ": " + TAB + entry.getValue().toString());
		}
		
	}
	
	public String toStringMapFaults(){
		String str = "";
		Set<Entry<Integer, List<String>>> set = mapFaults.entrySet();
		for(Entry<Integer, List<String>> entry:set){
			str = str + entry.getKey() + ": " + TAB;
			for(String s:entry.getValue()) {
				str = str + s + TAB; //+ ", ";
			}	
			str = str + EOL;
		}
		return str;
	}
	
	public String toStringMapFaultTCs(){
		String str = "";
		Set<Entry<Integer, List<Integer>>> set = mapFaultTCs.entrySet();
		for(Entry<Integer, List<Integer>> entry:set){
			str = str + entry.getKey() + ": " + TAB;
			for(Integer s:entry.getValue()) {
				str = str + s + ", ";
			}	
			str = str + EOL;
		}
		return str;
	}
	
	public TestCase getTestCase(int tcId){
		return mapTS.get(tcId);
	}
	
	public void toStringMapTCFaults(){
		System.out.println("toStringMapTCFaults");
		Set<Entry<Integer, List<Integer>>> set = mapTCFaults.entrySet();
		for(Entry<Integer, List<Integer>> entry:set){
			System.out.print(entry.getKey() + ": ");
			for(Integer str:entry.getValue()) {
				System.out.print(str + ", ");
			}	
			System.out.println();
		}
		
	}
	
	public double getPercentageOfOneFaultOneFailure(){
		int contOneFaultOneFailure = 0;
		Set<Entry<Integer, List<Integer>>> set = mapFaultTCs.entrySet();
		for(Entry<Integer, List<Integer>> entry:set){
			if(entry.getValue().size() == 1) {
				contOneFaultOneFailure = contOneFaultOneFailure + 1;
			}	
		}
		double percentageOneFaultOneFailure = 0.00;
		if(contOneFaultOneFailure > 0){
			percentageOneFaultOneFailure = (contOneFaultOneFailure * 100.00)/this.numberOfFaults();
		}
		return percentageOneFaultOneFailure;
	}
	
	private void createMapTS(TestSuite testSuite){
		List<TestCase> testCases = testSuite.getTestSuite();
		int idTC= 1;
		for(TestCase testCase:testCases){
			mapTS.put(idTC, testCase);
			idTC = idTC + 1;
		}
	}
	
	
	private void createMapFaults(Map<Integer, List<String>> map){
		this.mapFaults = new HashMap<Integer, List<String>>();
		Set<Entry<Integer, List<String>>> set = map.entrySet();
		Iterator<Entry<Integer, List<String>>> it = set.iterator();
		while(it.hasNext()){
			Entry<Integer, List<String>> entry = it.next();
			Integer idF = entry.getKey();
			mapFaults.put(idF, entry.getValue());
		}
	}
	
	private void createMapFaults(Map<Integer, List<String>> map, Set<Integer> faults){
		this.mapFaults = new HashMap<Integer, List<String>>();
		Set<Entry<Integer, List<String>>> set = map.entrySet();
		Iterator<Entry<Integer, List<String>>> it = set.iterator();
		while(it.hasNext()){
			Entry<Integer, List<String>> entry = it.next();
			Integer idF = entry.getKey();
			if(faults.contains(idF)){
				mapFaults.put(idF, entry.getValue());
			}
		}
	}
	
	private void createMapFaults(List<List<String>> faultsTransitions){
		int idFault = 1;
		for(List<String> fault:faultsTransitions) {
			mapFaults.put(idFault, fault);
			idFault = idFault + 1;
		}
	}
	
	public List<List<String>> getFaults(){
		List<List<String>> faultsList = new ArrayList<List<String>>();
		Set<Entry<Integer,List<String>>> set = mapFaults.entrySet();
		for(Entry<Integer,List<String>> entry:set){
			List<String> list = entry.getValue();
			faultsList.add(list);
		}
		return faultsList;
	}
	
	private void createFaultTestCases(){
		List<TestCase> testCases = this.getTestCases();
		for (Iterator<TestCase> iterator = testCases.iterator(); iterator.hasNext();) {
			TestCase testCase = (TestCase) iterator.next();
			String tc = "";
			for(InterfaceEdge e : testCase.getTestCase()) {
				tc = tc + e.getLabel() + "#";
			}
			
			Iterator<List<String>> it = getFaults().iterator();
			while(it.hasNext()){
				List<String> faultTC = it.next();
				String f = "";
				for (String string : faultTC) {
					f = f + string + "#";
				}
				
				if(tc.contains(f)){
					int idTC = getValueTestCase(testCase);
					int idFault = getValueFault(faultTC);
					if(mapFaultTCs.containsKey(idFault)){
						List<Integer> list = mapFaultTCs.get(idFault);
						list.add(idTC);
						mapFaultTCs.put(idFault, list);
					}else{
						List<Integer> list = new ArrayList<Integer>();
						list.add(idTC);
						mapFaultTCs.put(idFault, list);
					}
					
					if(mapTCFaults.containsKey(idTC)){
						List<Integer> list = mapTCFaults.get(idTC);
						list.add(idFault);
						mapTCFaults.put(idTC, list);
					}else{
						List<Integer> list = new ArrayList<Integer>();
						list.add(idFault);
						mapTCFaults.put(idTC, list);
					}						
				}
				
			}	
		}	
	}
	
	
	private void createFaultTestCases(Map<Integer, List<String>> mapFaults){
		
		Set<Entry<Integer, List<String>>> set = mapFaults.entrySet();
		Iterator<Entry<Integer, List<String>>> it = set.iterator();
		while(it.hasNext()){
			Entry<Integer, List<String>> entry = it.next();
			Integer idFault = entry.getKey();
			for(String tc: entry.getValue()){
				Integer idTC = Integer.parseInt(tc);
				if(mapFaultTCs.containsKey(idFault)){
					List<Integer> list = mapFaultTCs.get(idFault);
					list.add(idTC);
					mapFaultTCs.put(idFault, list);
				}else{
					List<Integer> list = new ArrayList<Integer>();
					list.add(idTC);
					mapFaultTCs.put(idFault, list);
				}
				
				if(mapTCFaults.containsKey(idTC)){
					List<Integer> list = mapTCFaults.get(idTC);
					list.add(idFault);
					mapTCFaults.put(idTC, list);
				}else{
					List<Integer> list = new ArrayList<Integer>();
					list.add(idFault);
					mapTCFaults.put(idTC, list);
				}		
			}
		}		
	}
	
	private void createFaultTestCases(Map<Integer, List<String>> mapFaults, List<TestCase> failures){
		Set<Entry<Integer, List<String>>> set = mapFaults.entrySet();
		Iterator<Entry<Integer, List<String>>> it = set.iterator();
		while(it.hasNext()){
			Entry<Integer, List<String>> entry = it.next();
			int idFault = entry.getKey();
			for(String tc: entry.getValue()){
				int idTC = Integer.parseInt(tc);
				if(failures.contains(tc)){
					if(mapFaultTCs.containsKey(idFault)){
						List<Integer> list = mapFaultTCs.get(idFault);
						list.add(idTC);
						mapFaultTCs.put(idFault, list);
					}else{
						List<Integer> list = new ArrayList<Integer>();
						list.add(idTC);
						mapFaultTCs.put(idFault, list);
					}
					
					if(mapTCFaults.containsKey(idTC)){
						List<Integer> list = mapTCFaults.get(idTC);
						list.add(idFault);
						mapTCFaults.put(idTC, list);
					}else{
						List<Integer> list = new ArrayList<Integer>();
						list.add(idFault);
						mapTCFaults.put(idTC, list);
					}		
				}
			}
		}		
	}
	
	private void createFaultTestCases(Set<Integer> faults){
		
		Set<Entry<Integer, List<String>>> set = mapFaults.entrySet();
		Iterator<Entry<Integer, List<String>>> it = set.iterator();
		while(it.hasNext()){
			Entry<Integer, List<String>> entry = it.next();
			Integer idFault = entry.getKey();
			if(faults.contains(idFault)){
				for(String tc: entry.getValue()){
					int idTC = Integer.parseInt(tc);
					if(mapFaultTCs.containsKey(idFault)){
						List<Integer> list = mapFaultTCs.get(idFault);
						list.add(idTC);
						mapFaultTCs.put(idFault, list);
					}else{
						List<Integer> list = new ArrayList<Integer>();
						list.add(idTC);
						mapFaultTCs.put(idFault, list);
					}
					
					if(mapTCFaults.containsKey(idTC)){
						List<Integer> list = mapTCFaults.get(idTC);
						list.add(idFault);
						mapTCFaults.put(idTC, list);
					}else{
						List<Integer> list = new ArrayList<Integer>();
						list.add(idFault);
						mapTCFaults.put(idTC, list);
					}		
				}
			}
		}		
	}
	
//	private void createFaultTestCases(List<TestCase> failures){
//		List<TestCase> testCases = this.getTestCases();
//		for (Iterator<TestCase> iterator = testCases.iterator(); iterator.hasNext();) {
//			TestCase testCase = (TestCase) iterator.next();
//			String tc = "";
//			for(InterfaceEdge e : testCase.getTestCase()) {
//				tc = tc + e.getLabel() + "#";
//			}
//			
//			Iterator<List<String>> it = getFaults().iterator();
//			while(it.hasNext()){
//				List<String> faultTC = it.next();
//				String f = "";
//				for (String string : faultTC) {
//					f = f + string + "#";
//				}
//				
//				if(tc.contains(f) & failures.contains(tc)){
//					int idTC = getValueTestCase(testCase);
//					int idFault = getValueFault(faultTC);
//					if(mapFaultTCs.containsKey(idFault)){
//						List<Integer> list = mapFaultTCs.get(idFault);
//						list.add(idTC);
//						mapFaultTCs.put(idFault, list);
//					}else{
//						List<Integer> list = new ArrayList<Integer>();
//						list.add(idTC);
//						mapFaultTCs.put(idFault, list);
//					}
//					
//					if(mapTCFaults.containsKey(idTC)){
//						List<Integer> list = mapTCFaults.get(idTC);
//						list.add(idFault);
//						mapTCFaults.put(idTC, list);
//					}else{
//						List<Integer> list = new ArrayList<Integer>();
//						list.add(idFault);
//						mapTCFaults.put(idTC, list);
//					}						
//				}
//				
//			}	
//		}	
//	}
	
//	private void createFaultTestCases(Set<Integer> faults){
//		List<TestCase> testCases = this.getTestCases();
//		for (Iterator<TestCase> iterator = testCases.iterator(); iterator.hasNext();) {
//			TestCase testCase = (TestCase) iterator.next();
//			String tc = "";
//			for(InterfaceEdge e : testCase.getTestCase()) {
//				tc = tc + e.getLabel() + "#";
//			}
//			
//			Iterator<List<String>> it = getFaults().iterator();
//			while(it.hasNext()){
//				List<String> faultTC = it.next();
//				String f = "";
//				for (String string : faultTC) {
//					f = f + string + "#";
//				}
//				
//				if(tc.contains(f) && faults.contains(this.getValueFault(faultTC))){
//					int idTC = getValueTestCase(testCase);
//					int idFault = getValueFault(faultTC);
//					if(mapFaultTCs.containsKey(idFault)){
//						List<Integer> list = mapFaultTCs.get(idFault);
//						list.add(idTC);
//						mapFaultTCs.put(idFault, list);
//					}else{
//						List<Integer> list = new ArrayList<Integer>();
//						list.add(idTC);
//						mapFaultTCs.put(idFault, list);
//					}
//					
//					if(mapTCFaults.containsKey(idTC)){
//						List<Integer> list = mapTCFaults.get(idTC);
//						list.add(idFault);
//						mapTCFaults.put(idTC, list);
//					}else{
//						List<Integer> list = new ArrayList<Integer>();
//						list.add(idFault);
//						mapTCFaults.put(idTC, list);
//					}						
//				}
//				
//			}	
//		}	
//	}
	
	public int numberFailures(){
		return mapTCFaults.size();
	}
	
//	public static void main(String[] args) {
//		Graph graph = null;
//		ReadTGF readTGF = new ReadTGF();
//				
//		try {
//			//graph = readTGF.getGraph("C:/Users/AnaEmilia/Documents/Doutorado/Projeto de Tese 02/experiment/models/pdfsam.tgf");
//			graph = readTGF.getGraph("pdfsam.tgf");
//		} catch (Exception e) {
//			System.out.println(e.getMessage());
//		}
//		
//		TreeGenerator generator = new TreeGenerator();
//		Tree tree = generator.converterGraph(graph);
//		tree.expand(1);
//		TesteCaseGeneratorGraph testeG = new TesteCaseGeneratorGraph();
//		TestSuite generatedSuite = testeG.getTestSuiteGraph(tree);
//		
//		List<List<String>> faults = new ArrayList<List<String>>();
//		//1
//		List<String> tc = new ArrayList<String>();
//		tc.add("01_1M");
//		tc.add("02_1M");
//		tc.add("02_2M");
//		tc.add("02_3M");
//		tc.add("02_4M");
//		tc.add("02_5M");
//		tc.add("01_2M");
//		tc.add("01_1A");
//		tc.add("01_7M");
//		tc.add("01_8M");
//		tc.add("01_9M");
//		tc.add("01_1D");
//		//tc.add("4185-UC_01-1B");
//		faults.add(tc);
//
//		//2
//		tc = new ArrayList<String>();		
//		tc.add("01_1M");
//		tc.add("07_1M");
//		tc.add("07_2M");
//		tc.add("07_3M");
//		tc.add("07_4M");
//		tc.add("07_1A");
//		tc.add("07_1C");
//		tc.add("07_2C");
//		tc.add("07_3C");
//		tc.add("01_2M");
//		tc.add("01_3M");
//		tc.add("01_4M");
//		tc.add("01_5M");
//		tc.add("01_6M");
//		tc.add("01_7M");
//		tc.add("01_8M");
//		tc.add("01_9M");
//		tc.add("01_10M"); 
//		faults.add(tc);
//		
//		//3
//		tc = new ArrayList<String>();
//		tc.add("01_1M");
//		tc.add("04_1M");
//		tc.add("04_2M");
//		tc.add("04_3M");
//		tc.add("04_4M");
//		tc.add("04_1B");
//		tc.add("04_2B");
//		tc.add("04_2M");
//		tc.add("04_3M");
//		tc.add("04_4M");
//		tc.add("04_1B");
//		tc.add("04_1D");
//		tc.add("04_5M");
//		tc.add("03_1M");
//		tc.add("03_1A");
//		tc.add("03_6M");
//		tc.add("03_7M");
//		tc.add("03_8M");
//		faults.add(tc);
//		
//		//4
//		tc = new ArrayList<String>();
//		tc.add("01_1M");
//		tc.add("04_1M");
//		tc.add("04_2M");
//		tc.add("04_3M");
//		tc.add("04_4M");
//		tc.add("04_1F");
//		tc.add("04_2M");
//		tc.add("04_3M");
//		tc.add("04_4M");
//		tc.add("04_5M");
//		tc.add("03_1M");
//		tc.add("03_1A");
//		tc.add("03_6M");
//		tc.add("03_7M");
//		tc.add("03_8M");
//		faults.add(tc);
//		
//		//5
//		tc = new ArrayList<String>();
//		tc.add("01_1M");
//		tc.add("08_1M");
//		tc.add("08_1C");
//		tc.add("08_5M");
//		tc.add("08_1J");
//		tc.add("08_7M");
//		tc.add("08_8M");
//		tc.add("03_1M");
//		tc.add("03_2M");
//		tc.add("03_3M");
//		tc.add("03_4M");
//		tc.add("03_5M");
//		tc.add("03_6M");
//		tc.add("03_7M");
//		tc.add("03_8M");
//		faults.add(tc);
//		
//		FaultTestSuite fts =  new FaultTestSuite(generatedSuite,faults);
//		
//		System.out.println("Mapa da Suite");
//		fts.toStringMapTS();
//		
//		System.out.println("Mapa das Faltas");
//		fts.toStringMapFaults();
//		
//		System.out.println("Casos de teste que falham para cada falta");
//		fts.toStringMapFaultTCs();
//		
//		System.out.println("Faltas que sao descobertas para cada caso de test");
//		fts.toStringMapTCFaults();
//		
//		
//	}

		
}
